// Pipit C标准库 - String模块实现
#include "pipit_stdlib.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdarg.h>

// 字符串连接
char* pipit_string_concat(const char* s1, const char* s2) {
    size_t len1 = strlen(s1);
    size_t len2 = strlen(s2);
    char* result = (char*)malloc(len1 + len2 + 1);
    if (!result) {
        return NULL; // 内存分配失败
    }
    memcpy(result, s1, len1);
    memcpy(result + len1, s2, len2 + 1);
    return result;
}

// 字符串长度
int pipit_string_length(const char* s) {
    return strlen(s);
}

// 字符串转大写
void pipit_string_to_upper(char* s) {
    for (int i = 0; s[i] != '\0'; i++) {
        s[i] = toupper(s[i]);
    }
}

// 字符串转小写
void pipit_string_to_lower(char* s) {
    for (int i = 0; s[i] != '\0'; i++) {
        s[i] = tolower(s[i]);
    }
}

// 比较两个字符串
int pipit_string_compare(const char* s1, const char* s2) {
    return strcmp(s1, s2);
}

// 查找子字符串
int pipit_string_find(const char* s, const char* substr) {
    char* pos = strstr(s, substr);
    if (pos) {
        return pos - s; // 返回子字符串的位置
    }
    return -1; // 未找到
}

// 字符串分割
pipit_string_split_t* pipit_string_split(const char* str, const char* delimiter) {
    if (!str || !delimiter) return NULL;
    
    char* str_copy = strdup(str);
    pipit_string_split_t* result = malloc(sizeof(pipit_string_split_t));
    result->tokens = malloc(64 * sizeof(char*)); // 预分配空间
    result->count = 0;
    
    char* token = strtok(str_copy, delimiter);
    while (token && result->count < 64) {
        result->tokens[result->count++] = strdup(token);
        token = strtok(NULL, delimiter);
    }
    
    free(str_copy);
    return result;
}

// 字符串替换
char* pipit_string_replace(const char* str, const char* old, const char* new) {
    if (!str || !old || !new) return NULL;
    
    int count = 0;
    const char* tmp = str;
    while ((tmp = strstr(tmp, old))) {
        count++;
        tmp += strlen(old);
    }
    
    size_t new_len = strlen(str) + count * (strlen(new) - strlen(old)) + 1;
    char* result = malloc(new_len);
    
    char* dst = result;
    const char* src = str;
    const char* match;
    while ((match = strstr(src, old))) {
        size_t len = match - src;
        memcpy(dst, src, len);
        dst += len;
        memcpy(dst, new, strlen(new));
        dst += strlen(new);
        src = match + strlen(old);
    }
    strcpy(dst, src);
    
    return result;
}

// 字符串修剪（去除前后空格）
char* pipit_string_trim(const char* str) {
    if (!str) return NULL;
    
    while (isspace((unsigned char)*str)) str++;
    if (*str == 0) return strdup("");
    
    const char* end = str + strlen(str) - 1;
    while (end > str && isspace((unsigned char)*end)) end--;
    end++;
    
    char* result = malloc(end - str + 1);
    memcpy(result, str, end - str);
    result[end - str] = '\0';
    return result;
}

// 字符串截取
char* pipit_string_substring(const char* str, int start, int end) {
    if (!str || start < 0 || end < start) return NULL;
    
    int len = strlen(str);
    if (end > len) end = len;
    if (start > len) start = len;
    
    char* result = malloc(end - start + 1);
    memcpy(result, str + start, end - start);
    result[end - start] = '\0';
    return result;
}

// 字符串是否以指定前缀开始
int pipit_string_starts_with(const char* str, const char* prefix) {
    if (!str || !prefix) return 0;
    return strncmp(str, prefix, strlen(prefix)) == 0;
}

// 字符串是否以指定后缀结束
int pipit_string_ends_with(const char* str, const char* suffix) {
    if (!str || !suffix) return 0;
    size_t str_len = strlen(str);
    size_t suffix_len = strlen(suffix);
    if (suffix_len > str_len) return 0;
    return strcmp(str + str_len - suffix_len, suffix) == 0;
}

// 字符串转换为整数
int pipit_string_to_int(const char* str) {
    if (!str) return 0;
    return atoi(str);
}

// 字符串转换为浮点数
double pipit_string_to_double(const char* str) {
    if (!str) return 0.0;
    return atof(str);
}

// 格式化字符串（简化版）
char* pipit_string_format(const char* format, ...) {
    va_list args;
    va_start(args, format);
    
    // 计算所需缓冲区大小
    va_list args_copy;
    va_copy(args_copy, args);
    int size = vsnprintf(NULL, 0, format, args_copy);
    va_end(args_copy);
    
    if (size < 0) return NULL;
    
    char* buffer = malloc(size + 1);
    if (!buffer) return NULL;
    
    vsnprintf(buffer, size + 1, format, args);
    va_end(args);
    
    return buffer;
}

// 释放分割结果
void pipit_string_split_free(pipit_string_split_t* split) {
    if (!split) return;
    for (int i = 0; i < split->count; i++) {
        free(split->tokens[i]);
    }
    free(split->tokens);
    free(split);
}